{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 运行版本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.8.13 (default, Mar 28 2022, 06:59:08) [MSC v.1916 64 bit (AMD64)]'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.6.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow\n",
    "\n",
    "tensorflow.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.10.1'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !python -m deepxde.backend.set_default_backend pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using backend: tensorflow.compat.v1\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\tensorflow\\python\\compat\\v2_compat.py:101: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n",
      "WARNING:tensorflow:From G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\deepxde\\nn\\initializers.py:118: The name tf.keras.initializers.he_normal is deprecated. Please use tf.compat.v1.keras.initializers.he_normal instead.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'1.1.3'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import deepxde\n",
    "\n",
    "deepxde.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 输运方程(Transport equation)\n",
    "\n",
    "下面记 $u = u(x,t), x=(x_1,\\cdots,x_n) \\in \\mathbb{R}^n, t \\geq 0$ ，$x$ 是空间中的一个点，$t$ 是时间。$Du = D_x u = (u_{x_1},\\cdots,u_{x_n})$是代表 $u$ 关于空间变量 $x$ 的梯度。$u_t$ 代表 $u$ 关于时间的偏导数。\n",
    "\n",
    "**定义1.1** 偏微分方程\n",
    "$$\n",
    "\\large u_t + b \\cdot D_u = 0,(x,t) \\in \\mathbb{R}^n \\times (0,\\infty)    \\tag{1}\n",
    "$$\n",
    "是**输运方程(transport equation)**，这里 $b=(b_1,\\cdots,b_n) \\in \\mathbb{R}^n$ 是个固定的向量。\n",
    "\n",
    "为了解这个PDE，我们现在就不妨设 $u$ 有某个光滑的解然后再尝试计算它。首先注意到方程(1)表明 $u$ 的某个特定方向的导数为0, 我们固定任意的点 $(x,t) \\in \\mathbb{R}^n \\times (0,\\infty)$ 并定义 $\\large z(s) \\triangleq u(x+sb,t+s) s \\in \\mathbb{R}$，\n",
    "\n",
    "以下都记 $\\frac {d} {ds} = \\dot{} $，利用方程(1)计算得到 $\\large \\dot z(s) = Du(x+sb,t+s) · b + u_t(x+sb,t+s) = 0$。\n",
    "\n",
    "因此 $z(·{})$ 是关于 $s$ 的常函数，所以对每个点 $(x,t)$，$u$ 在穿过 $(x,t)$ 且方向是 $(b,1) \\in \\mathbb{R}^{n+1}$ 的直线(记为 $l$ )上是个常数。因此，如果我们知道了直线 $l$ 上任意一个点的 $u$ 值，我们就知道了这条直线 $l$ 的值。\n",
    "\n",
    "## 1.1 初值问题\n",
    "\n",
    "为了确定所需要的解, 考虑如下初值问题\n",
    "$$\n",
    "\\large\n",
    "\\begin{cases}\n",
    "\\begin{aligned}\n",
    "u_t+b· D_u &= 0, in \\ \\mathbb{R}^n \\times (0,\\infty) \\\\ \n",
    "u &= g, on \\ \\mathbb{R}^n \\times \\{t=0\\}.  \\\\ \n",
    "\\end{aligned}\n",
    "\\end{cases} \n",
    "\\tag{2}\n",
    "$$\n",
    "这里 $b \\in \\mathbb{R}^n,g:\\mathbb{R}^n \\to \\mathbb{R}$ 给定, 现在要求出 $u$ 的表达式。\n",
    "\n",
    "固定了上述 $(x,t)$，穿过 $(x,t)$ 且方向为 $(b,1)$ 的直线可以用参数方程 $(x+sb,t+s) (s \\in \\mathbb{R})$ 表示，当 $s=-t$ 时，这条直线打在平面$\\Gamma := \\mathbb{R}^n \\times \\{t=0\\}$ 上，且交点是 $(x-tb,0)$。由于 $u$ 是直线上的常数，且 $u(x-tb,0)=g(x-tb)$，因此\n",
    "$$\n",
    "\\large u(x,t) = g(x-tb),x \\in \\mathbb{R}^n,t \\geq 0.\\tag{3}\n",
    "$$\n",
    "因此如果方程(2)有足够好的解 $u$，则这个解一定形如(3)。另一方面，容易判断如果$g \\in C^1$，则式(3)满足方程(2)。\n",
    "\n",
    "**注:** 如果 $g \\not \\in C^1$，显然方程(2)没有解 $C^1$，则这个解叫做“**弱解**”。不过有时候不光滑甚至是不连续的函数都可以作为PDE的一个弱解。\n",
    "\n",
    "## 1.2 非齐次初值问题\n",
    "\n",
    "下面考虑非齐次方程\n",
    "$$\n",
    "\\large\n",
    "\\begin{cases}\n",
    "\\begin{aligned}\n",
    "u_t+b · D_u &= f, in \\ \\mathbb{R}^n \\times (0,\\infty) \\\\ \n",
    "u &= g, on \\ \\mathbb{R}^n \\times \\{t=0\\}.  \\\\ \n",
    "\\end{aligned}\n",
    "\\end{cases}\n",
    "\\tag{4}\n",
    "$$\n",
    "受前面过程启发，我们与前面类似，固定 $(x,t) \\in \\mathbb{R}^{n+1}$，记 $\\large z(s) \\triangleq u(x+sb,t+s) s \\in \\mathbb{R}$，则$\\large \\dot z(s) = Du(x+sb,t+s) · b + u_t(x+sb,t+s) = f(x+sb,t+s)$。\n",
    "\n",
    "因此\n",
    "$$\n",
    "\\large\n",
    "\\begin{align*}\n",
    "u(x,t) - g(x-tb) &= z(0) - z(-t) = \\int^0_{-t} \\dot{z}(s) ds \\\\\n",
    "&= \\int^0_{-t} f(x+sb,t+s) ds   \\\\ \n",
    "&= \\int^t_{0} f(x+(s-t)b,s) ds,   \\\\\n",
    "\\end{align*}\n",
    "$$\n",
    "因此 $\\large u(x,t) = g(x-tb) + \\int^t_{0} f(x+(s-t)b,s) ds, x\\in \\mathbb{R}^n,t \\geq 0$是初值问题(4)的解。这个方程可以被用来解一维的波动方程。\n",
    "\n",
    "**注：**注意到我们实际上是通过有效地把PDE转变成ODE最终得到PDE的解，这些步骤是“**特性曲线法**”的一种特例。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 问题设置\n",
    "下面考虑非齐次方程\n",
    "$$\n",
    "\\large\n",
    "\\begin{cases}\n",
    "\\begin{aligned}\n",
    "u_t+2 · D_u &= x, in \\ \\mathbb{R}^1 \\times (0,\\infty) \\\\ \n",
    "u &= x^2, on \\ \\mathbb{R}^1 \\times \\{t=0\\}.  \\\\ \n",
    "\\end{aligned}\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "当我们用DeepXDE求解上式时，应该改写为\n",
    "$$\\large u_t+2 · u_x = x, x \\in [−1,1], t \\in [0,1]$$\n",
    "\n",
    "初始条件 $\\large u(x,0) = x^2, $ \n",
    "\n",
    "\n",
    "使用mathematica来求解\n",
    "\n",
    "```mathematica\n",
    "sol = DSolve[{D[u[t, x], t] + 2*D[u[t, x], x] == x, u[0, x] == x^2}, \n",
    "   u[t, x], {t, x}];\n",
    "TraditionalForm[u[t, x] /. sol[[1]]]\n",
    "```\n",
    "\n",
    "得到的答案为：$\\large u(x,t) = 3t^2-3tx+x^2$ 。\n",
    "\n",
    "### 参考代码：\n",
    "https://deepxde.readthedocs.io/en/latest/demos/pinn_forward/burgers.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 执行\n",
    "\n",
    "本描述逐步介绍了上述transport equation的求解器的实现。\n",
    "\n",
    "首先，导入 DeepXDE 和 TensorFlow ( `tf`) 模块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using backend: tensorflow.compat.v1\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\tensorflow\\python\\compat\\v2_compat.py:101: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n",
      "WARNING:tensorflow:From G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\deepxde\\nn\\initializers.py:118: The name tf.keras.initializers.he_normal is deprecated. Please use tf.compat.v1.keras.initializers.he_normal instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import deepxde as dde\n",
    "from deepxde.backend import tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "我们首先定义一个计算几何和时域。我们可以使用内置类`Interval`，并且我们使用以下方式`TimeDomain`组合两个域`GeometryXTime`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "geom = dde.geometry.Interval(-1, 1)\n",
    "timedomain = dde.geometry.TimeDomain(0, 0.99)\n",
    "geomtime = dde.geometry.GeometryXTime(geom, timedomain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，我们表达 transport 方程的 PDE 残差：\n",
    "\n",
    "$\\large u_t+2 · u_x = x, x \\in [−1,1], t \\in [0,1]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pde(x, y):\n",
    "    dy_x = dde.grad.jacobian(y, x, i=0, j=0)\n",
    "    dy_t = dde.grad.jacobian(y, x, i=0, j=1)\n",
    "    return dy_t + 2 * dy_x - x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，我们考虑边界/初始条件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ic = dde.icbc.IC(geomtime, lambda x: -np.sin(np.pi * x[:, 0:1]), lambda _, on_initial: on_initial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在，我们已经指定了几何、PDE 残差和边界/初始条件。然后我们将`TimePDE`问题定义为"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\skopt\\sampler\\sobol.py:246: UserWarning: The balance properties of Sobol' points require n to be a power of 2. 0 points have been previously generated, then: n=0+2542=2542. \n",
      "  warnings.warn(\"The balance properties of Sobol' points require \"\n",
      "G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\skopt\\sampler\\sobol.py:246: UserWarning: The balance properties of Sobol' points require n to be a power of 2. 0 points have been previously generated, then: n=0+82=82. \n",
      "  warnings.warn(\"The balance properties of Sobol' points require \"\n",
      "G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\skopt\\sampler\\sobol.py:246: UserWarning: The balance properties of Sobol' points require n to be a power of 2. 0 points have been previously generated, then: n=0+162=162. \n",
      "  warnings.warn(\"The balance properties of Sobol' points require \"\n"
     ]
    }
   ],
   "source": [
    "data = dde.data.TimePDE(geomtime, pde, [ic],\n",
    "                        num_domain=2540, num_boundary=80, num_initial=160)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数字 2540 是在域内采样的训练残差点数，数字 80 是在边界上采样的训练点数。我们还包括初始条件的 160 个初始残差点。\n",
    "\n",
    "接下来，我们选择网络。在这里，我们使用深度为 4（即 3 个隐藏层）和宽度为 20 的全连接神经网络："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = dde.nn.FNN([2] + [20] * 3 + [1], \"tanh\", \"Glorot normal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在，我们有 PDE 问题和网络。我们构建一个`Model`并选择优化器和学习率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling model...\n",
      "Building feed-forward neural network...\n",
      "'build' took 0.060587 s\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\keras\\legacy_tf_layers\\core.py:236: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.\n",
      "  warnings.warn('`tf.layers.dense` is deprecated and '\n",
      "G:\\Anaconda3\\envs\\py3.8\\lib\\site-packages\\keras\\engine\\base_layer_v1.py:1676: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.\n",
      "  warnings.warn('`layer.apply` is deprecated and '\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'compile' took 1.334987 s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model = dde.Model(data, net)\n",
    "model.compile(\"adam\", lr=1e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后我们训练模型进行 10000 次迭代："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing variables...\n",
      "Training model...\n",
      "\n",
      "Step      Train loss              Test loss               Test metric\n",
      "0         [5.61e-01, 6.59e-01]    [5.61e-01, 6.59e-01]    []  \n",
      "1000      [1.67e-01, 9.25e-03]    [1.67e-01, 9.25e-03]    []  \n",
      "2000      [1.66e-01, 4.02e-04]    [1.66e-01, 4.02e-04]    []  \n",
      "3000      [1.66e-01, 3.68e-05]    [1.66e-01, 3.68e-05]    []  \n",
      "4000      [1.66e-01, 1.85e-05]    [1.66e-01, 1.85e-05]    []  \n",
      "5000      [1.66e-01, 4.29e-06]    [1.66e-01, 4.29e-06]    []  \n",
      "6000      [1.66e-01, 1.71e-06]    [1.66e-01, 1.71e-06]    []  \n",
      "7000      [1.66e-01, 9.44e-06]    [1.66e-01, 9.44e-06]    []  \n",
      "8000      [1.66e-01, 1.59e-06]    [1.66e-01, 1.59e-06]    []  \n",
      "9000      [1.66e-01, 2.64e-06]    [1.66e-01, 2.64e-06]    []  \n",
      "10000     [1.66e-01, 3.08e-07]    [1.66e-01, 3.08e-07]    []  \n",
      "\n",
      "Best model at step 10000:\n",
      "  train loss: 1.66e-01\n",
      "  test loss: 1.66e-01\n",
      "  test metric: []\n",
      "\n",
      "'train' took 18.607478 s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "losshistory, train_state = model.train(epochs=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在我们使用 Adam 训练网络之后，我们继续使用 L-BFGS 训练网络以实现更小的损失："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling model...\n",
      "'compile' took 0.117822 s\n",
      "\n",
      "Training model...\n",
      "\n",
      "Step      Train loss              Test loss               Test metric\n",
      "10019     [1.66e-01, 3.08e-07]    [1.66e-01, 3.08e-07]    []  \n",
      "INFO:tensorflow:Optimization terminated with:\n",
      "  Message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n",
      "  Objective function value: 0.165597\n",
      "  Number of iterations: 1\n",
      "  Number of functions evaluations: 22\n",
      "10041     [1.66e-01, 3.08e-07]    [1.66e-01, 3.08e-07]    []  \n",
      "\n",
      "Best model at step 10000:\n",
      "  train loss: 1.66e-01\n",
      "  test loss: 1.66e-01\n",
      "  test metric: []\n",
      "\n",
      "'train' took 0.300388 s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model.compile(\"L-BFGS-B\")\n",
    "losshistory, train_state = model.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saveplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "\n",
    "def plot_loss_history(loss_history, figsize=(10, 8)):\n",
    "    \"\"\"Plot the training and testing loss history.\n",
    "\n",
    "    Note:\n",
    "        You need to call ``plt.show()`` to show the figure.\n",
    "\n",
    "    Args:\n",
    "        loss_history: ``LossHistory`` instance. The first variable returned from\n",
    "            ``Model.train()``.\n",
    "    \"\"\"\n",
    "    loss_train = np.sum(loss_history.loss_train, axis=1)\n",
    "    loss_test = np.sum(loss_history.loss_test, axis=1)\n",
    "\n",
    "    plt.figure(figsize=figsize)\n",
    "    plt.semilogy(loss_history.steps, loss_train, label=\"Train loss\")\n",
    "    plt.semilogy(loss_history.steps, loss_test, label=\"Test loss\")\n",
    "    for i in range(len(loss_history.metrics_test[0])):\n",
    "        plt.semilogy(\n",
    "            loss_history.steps,\n",
    "            np.array(loss_history.metrics_test)[:, i],\n",
    "            label=\"Test metric\",\n",
    "        )\n",
    "    plt.xlabel(\"Steps\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "def _pack_data(train_state):\n",
    "    def merge_values(values):\n",
    "        if values is None:\n",
    "            return None\n",
    "        return np.hstack(values) if isinstance(values, (list, tuple)) else values\n",
    "\n",
    "    y_train = merge_values(train_state.y_train)\n",
    "    y_test = merge_values(train_state.y_test)\n",
    "    best_y = merge_values(train_state.best_y)\n",
    "    best_ystd = merge_values(train_state.best_ystd)\n",
    "    return y_train, y_test, best_y, best_ystd\n",
    "\n",
    "def plot_best_state(train_state, figsize=(10, 6)):\n",
    "    \"\"\"Plot the best result of the smallest training loss.\n",
    "\n",
    "    This function only works for 1D and 2D problems. For other problems and to better\n",
    "    customize the figure, use ``save_best_state()``.\n",
    "\n",
    "    Note:\n",
    "        You need to call ``plt.show()`` to show the figure.\n",
    "\n",
    "    Args:\n",
    "        train_state: ``TrainState`` instance. The second variable returned from\n",
    "            ``Model.train()``.\n",
    "    \"\"\"\n",
    "    if isinstance(train_state.X_train, (list, tuple)):\n",
    "        print(\n",
    "            \"Error: The network has multiple inputs, and plotting such result han't been implemented.\"\n",
    "        )\n",
    "        return\n",
    "\n",
    "    y_train, y_test, best_y, best_ystd = _pack_data(train_state)\n",
    "    y_dim = best_y.shape[1]\n",
    "\n",
    "    # Regression plot\n",
    "    # 1D\n",
    "    if train_state.X_test.shape[1] == 1:\n",
    "        idx = np.argsort(train_state.X_test[:, 0])\n",
    "        X = train_state.X_test[idx, 0]\n",
    "        plt.figure(figsize=figsize)\n",
    "        for i in range(y_dim):\n",
    "            if y_train is not None:\n",
    "                plt.plot(train_state.X_train[:, 0], y_train[:, i], \"ok\", label=\"Train\")\n",
    "            if y_test is not None:\n",
    "                plt.plot(X, y_test[idx, i], \"-k\", label=\"True\")\n",
    "            plt.plot(X, best_y[idx, i], \"--r\", label=\"Prediction\")\n",
    "            if best_ystd is not None:\n",
    "                plt.plot(\n",
    "                    X, best_y[idx, i] + 2 * best_ystd[idx, i], \"-b\", label=\"95% CI\"\n",
    "                )\n",
    "                plt.plot(X, best_y[idx, i] - 2 * best_ystd[idx, i], \"-b\")\n",
    "        plt.xlabel(\"x\")\n",
    "        plt.ylabel(\"y\")\n",
    "        plt.legend()\n",
    "    # 2D\n",
    "    elif train_state.X_test.shape[1] == 2:\n",
    "        for i in range(y_dim):\n",
    "            plt.figure(figsize=tuple([i*2 for i in figsize]))\n",
    "            ax = plt.axes(projection=Axes3D.name)\n",
    "            ax.plot3D(\n",
    "                train_state.X_test[:, 0],\n",
    "                train_state.X_test[:, 1],\n",
    "                best_y[:, i],\n",
    "                \".\",\n",
    "            )\n",
    "            ax.set_xlabel(\"$x_1$\")\n",
    "            ax.set_ylabel(\"$x_2$\")\n",
    "            ax.set_zlabel(\"$y_{}$\".format(i + 1))\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss_history(losshistory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_best_state(train_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3.8",
   "language": "python",
   "name": "py3.8"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
